package daliy;

import java.time.temporal.Temporal;
import java.util.*;

public class Daily {

//    public static void main(String[] args) {
//        Daily daily = new Daily();
////        boolean powerOfThree = daily.isPowerOfThree(0);
////        System.out.println(powerOfThree);
//        boolean powerOfThree = daily.checkPowersOfThree(91);
//        System.out.println(powerOfThree);
//    }


    //水果篮子
    //给你两个长度为 n 的整数数组，fruits 和 baskets，其中 fruits[i] 表示第 i 种水果的 数量，baskets[j] 表示第 j 个篮子的 容量。
    //你需要对 fruits 数组从左到右按照以下规则放置水果：
    //
    //每种水果必须放入第一个 容量大于等于 该水果数量的 最左侧可用篮子 中。
    //每个篮子只能装 一种 水果。
    //如果一种水果 无法放入 任何篮子，它将保持 未放置。
    //返回所有可能分配完成后，剩余未放置的水果种类的数量
    public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
        return 0;
    }

    //最大矩形
    public int largestRectangleArea(int[] heights) {
        String a = "";
        return 0;
    }

    //给定一个整数，写一个函数来判断它是否是 3 的幂次方。如果是，返回 true ；否则，返回 false 。
    //
    //整数 n 是 3 的幂次方需满足：存在整数 x 使得 n == 3x
    public boolean isPowerOfThree(int n) {
        if(n == 1){
            return true;
        }
        if(n % 3 != 0 || n == 0){
            return false;
        }
        if(n != 3){
            return isPowerOfThree(n / 3);
        }else {
            return true;
        }
    }


    //给定一个整数 n ，返回 n! 结果中尾随零的数量
    public int trailingZeroes(int n) {
        if(n == 0){
            return 1;
        }
        return 0;
    }

    //判断麻将是否胡了
    public int huLe(int[] tiles) {
        Arrays.sort(tiles);
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < tiles.length; i++){
            map.put(tiles[i],map.getOrDefault(tiles[i],0) + 1);
        }
        for(Map.Entry<Integer,Integer> entry : map.entrySet()){

        }
        return 1;
    }

    //给你一个整数 n ，如果你可以将 n 表示成若干个不同的三的幂之和，请你返回 true ，否则请返回 false 。
    //
    //对于一个整数 y ，如果存在整数 x 满足 y == 3x ，我们称这个整数 y 是三的幂
    public boolean checkPowersOfThree(int n) {
        while (n != 0) {
            if (n % 3 == 2) {
                return false;
            }
            n /= 3;
        }
        return true;
    }

    //设计一个算法，找出数组中最小的k个数。以任意顺序返回这k个数均可
    public int[] smallestK(int[] arr, int k) {
        Stack<Integer> stack = new Stack<>();
        for (int i : arr) {
            if(stack.peek() == null){
                stack.push(i);
            }
            if(stack.size() < k && i < stack.peek()){

            }
        }
        return null;
    }

    public void swap(Stack stack, int i){

    }

    public boolean canConstruct(String ransomNote, String magazine) {
        HashMap<Character,Integer> map = new HashMap<>();
        for(int i = 0; i < magazine.length(); i++){
            char c = magazine.charAt(i);
            map.put(c,map.getOrDefault(c ,0) + 1);
        }

        for(int i = 0; i < ransomNote.length(); i++){
            char c = ransomNote.charAt(i);
            if(map.get(c) == null || map.get(c) == 0){
                return false;
            }else {
                map.put(c,map.get(c)- 1);
            }
        }
        return true;
    }

    //一所学校里有一些班级，每个班级里有一些学生，现在每个班都会进行一场期末考试。给你一个二维数组 classes ，其中 classes[i] = [passi, totali] ，
    // 表示你提前知道了第 i 个班级总共有 totali 个学生，
    // 其中只有 passi 个学生可以通过考试。
    //给你一个整数 extraStudents ，表示额外有 extraStudents 个聪明的学生，他们 一定 能通过任何班级的期末考。你需要给这 extraStudents 个学生每人都安排一个班级，使得 所有 班级的 平均 通过率 最大 。
    //
    //一个班级的 通过率 等于这个班级通过考试的学生人数除以这个班级的总人数。平均通过率 是所有班级的通过率之和除以班级数目。
    //
    //请你返回在安排这 extraStudents 个学生去对应班级后的 最大 平均通过率。与标准答案误差范围在 10-5 以内的结果都会视为正确结果
    public double maxAverageRatio(int[][] classes, int extraStudents) {
        if (classes == null){
            return 0;
        }
        Arrays.sort(classes, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return  ((o1[0]+ 1) / (o1[1] + 1)  -  (o1[0] / o1[1])) -  ((o2[0]+ 1) / (o2[1] + 1)  -  (o2[0] / o2[1]));
            }
        });
        return 0;
    }

    //Alice 和 Bob 在一片田野上玩一个回合制游戏，他们之间有两排花。Alice 和 Bob 之间第一排有 x 朵花，第二排有 y 朵花。
    //
    //
    //
    //游戏过程如下：
    //
    //Alice 先行动。
    //每一次行动中，当前玩家必须选择其中一排，然后在这边摘一朵鲜花。
    //一次行动结束后，如果两排上都没有剩下鲜花，那么 当前 玩家抓住对手并赢得游戏的胜利。
    //给你两个整数 n 和 m ，你的任务是求出满足以下条件的所有 (x, y) 对：
    //
    //按照上述规则，Alice 必须赢得游戏。
    //第一排的鲜花数目 x 必须在区间 [1,n] 之间。
    //第二排的鲜花数目 y 必须在区间 [1,m] 之间。
    //请你返回满足题目描述的数对 (x, y) 的数目


    public long flowerGame(int n, int m) {
        int x1 = 0;
        int x2 = 0;
        int y1 = 0;
        int y2 = 0;
        x1 = n / 2;
        if(n % 2 == 0) {
            x2 = x1;
        }else {
            x2 = x1 + 1;
        }
        y1 = m / 2;
        if(m % 2 == 0) {
            y2 = y1;
        }else {
            y2 = y1 + 1;
        }
        long res = (x1 * y2) + (x2 * y1);
        return res;
    }

        public static void main(String[] args) {
            Daily daily = new Daily();

            // 测试用例1: n=3, m=2
            // 所有可能的(x,y)对: (1,1), (1,2), (2,1), (2,2), (3,1), (3,2)
            // 分析每种情况:
            // (1,1): Alice拿1朵 -> (0,1), Bob拿1朵 -> (0,0) Bob获胜
            // (1,2): Alice拿1朵 -> (0,2), Bob拿1朵 -> (0,1), Alice拿1朵 -> (0,0) Alice获胜
            // (2,1): Alice拿1朵 -> (1,1), Bob拿1朵 -> (0,1), Alice拿1朵 -> (0,0) Alice获胜
            // (2,2): Alice拿1朵 -> (1,2), Bob拿1朵 -> (0,2), Alice拿1朵 -> (0,1), Bob拿1朵 -> (0,0) Bob获胜
            // (3,1): Alice拿1朵 -> (2,1), Bob拿1朵 -> (1,1), Alice拿1朵 -> (0,1), Bob拿1朵 -> (0,0) Bob获胜
            // (3,2): Alice拿1朵 -> (2,2), Bob拿1朵 -> (1,2), Alice拿1朵 -> (0,2), Bob拿1朵 -> (0,1), Alice拿1朵 -> (0,0) Alice获胜
            // Alice获胜的情况: (1,2), (2,1), (3,2) 共3种
            int n1 = 3, m1 = 2;
            long result1 = daily.flowerGame(n1, m1);
            System.out.println("测试用例1结果 (n=3, m=2): " + result1);
            // 预期结果: 3

            // 测试用例2: n=1, m=1
            // 只有一种情况: (1,1)
            // (1,1): Alice拿1朵 -> (0,1), Bob拿1朵 -> (0,0) Bob获胜
            // Alice获胜的情况: 0种
            int n2 = 1, m2 = 5;
            long result2 = daily.flowerGame(n2, m2);
            System.out.println("测试用例2结果 (n=1, m=1): " + result2);
            // 预期结果: 0

            // 测试用例3: n=2, m=2
            // 所有可能的(x,y)对: (1,1), (1,2), (2,1), (2,2)
            // (1,1): Alice拿1朵 -> (0,1), Bob拿1朵 -> (0,0) Bob获胜
            // (1,2): Alice拿1朵 -> (0,2), Bob拿1朵 -> (0,1), Alice拿1朵 -> (0,0) Alice获胜
            // (2,1): Alice拿1朵 -> (1,1), Bob拿1朵 -> (0,1), Alice拿1朵 -> (0,0) Alice获胜
            // (2,2): Alice拿1朵 -> (1,2), Bob拿1朵 -> (0,2), Alice拿1朵 -> (0,1), Bob拿1朵 -> (0,0) Bob获胜
            // Alice获胜的情况: (1,2), (2,1) 共2种
            int n3 = 2, m3 = 2;
            long result3 = daily.flowerGame(n3, m3);
            System.out.println("测试用例3结果 (n=2, m=2): " + result3);
            // 预期结果: 2

            // 测试用例4: n=3, m=3
            // 总共9种情况
            int n4 = 3, m4 = 3;
            long result4 = daily.flowerGame(n4, m4);
            System.out.println("测试用例4结果 (n=3, m=3): " + result4);
            // 预期结果: 4

            // 测试用例5: n=4, m=4
            // 总共16种情况
            int n5 = 4, m5 = 4;
            long result5 = daily.flowerGame(n5, m5);
            System.out.println("测试用例5结果 (n=4, m=4): " + result5);
            // 预期结果: 8

            // 测试用例6: n=10, m=5
            int n6 = 10, m6 = 5;
            long result6 = daily.flowerGame(n6, m6);
            System.out.println("测试用例6结果 (n=10, m=5): " + result6);
            // 预期结果: 25
        }


}
